home *** CD-ROM | disk | FTP | other *** search
/ The CICA Windows Explosion! / The CICA Windows Explosion! - Disc 2.iso / programr / appsrcs.zip / APPBAR.ZIP / APPGRP.C < prev    next >
C/C++ Source or Header  |  1993-04-26  |  8KB  |  212 lines
  1. //----------------------------------------------------------------------
  2. // File name: appgrp.c                  Creation date: 921006
  3. //
  4. // Abstract:  This is a source file to show how to read the Windows 
  5. //            3.1 group file.  Please note that all of this may change 
  6. //            in a future release of the Windows operating system.
  7. //    
  8. //            This program works by going out and finding the PROGMAN.INI
  9. //            file.  A sample PROGMAN.INI file looks like the following:
  10. //
  11. //            [Settings]
  12. //              Window=428 465 1011 733 1
  13. //              SaveSettings=0
  14. //              display.drv=8514.drv
  15. //        Order= 6 4 2 9 3 8 1 7 5
  16. //            [Groups]
  17. //              Group1=C:\WINDOWS\MAIN0.GRP
  18. //              Group2=C:\WINDOWS\ACCESSO0.GRP
  19. //              Group4=C:\WINDOWS\STARTUP.GRP
  20. //              Group5=C:\WINDOWS\DOSAPPS.GRP
  21. //              Group8=C:\WINDOWS\MICROSOF.GRP
  22. //              Group9=C:\WINDEV\SDKTOOLS.GRP
  23. //
  24. //            It uses the information in the PROGMAN.INI file to list 
  25. //            the information in the opening listbox.  In order to get 
  26. //            information about items in the group, the program opens 
  27. //            the file listed in this list box.
  28. //
  29. //            The program then goes out and reads in the entire group
  30. //            file specified in the opening list box and displays the
  31. //            items in a secondary list box.  It uses structures 
  32. //            specified in the group file format document in the 
  33. //            Windows 3.1 SDK to find where the items are located 
  34. //            within the file.  To demonstrate how to read an item,
  35. //            ShowGrp reads in the item's icon and displays it in a 
  36. //            dialog box.
  37. //
  38. // Copyright (c) 1992 Microsoft Corporation. All rights reserved.
  39. //----------------------------------------------------------------------
  40. #include <windows.h>
  41. #include <stdlib.h>
  42. #include <memory.h>
  43. #include <string.h>
  44. #include "appbar.h"
  45. #include "appgrp.h"
  46.  
  47. #define BUFSIZE        256
  48.  
  49. HGLOBAL    ghMemGroupFileData;   // Handle to global memory which
  50.                   // holds the group file data.
  51. WORD cbGroup;              // WORD value to specify length of groupfile
  52.  
  53. int ShouldAppBeMinimized(WORD);
  54.  
  55. //----------------------------------------------------------------------
  56. //     Function:  SetItemInfo 
  57. //
  58. //    Purpose:  Fills in item data into the list box specified
  59. //                by the hWndList parameter
  60. //
  61. // Return Value:  void 
  62. //--------------------------------------------------------------------
  63. BOOL ExecGroupFile(char *szGroupFileName)
  64. {
  65.   PMGROUPHEADER PMGroupHeader;          // Header for the group file
  66.   PMITEMDATA    PMItemData;           // Pointer to the group file data
  67.   WORD      FAR *rgiItems;            // Array of item offset in group file
  68.   WORD          cItems;               // Count of items 
  69.   WORD          i;                    // Generic counter
  70.   char        szCommand [BUFSIZE];  // Buffer to hold command
  71.   char        *szTemp;          // Temporary char pointer
  72.  
  73.  
  74.   if (!ReadGroupFile ((LPSTR) szGroupFileName, &ghMemGroupFileData))
  75.       return FALSE;
  76.  
  77.   // Get the Group File header information
  78.  
  79.   //**************************************************************
  80.   //  The rgiItems array in the group file may not have valid
  81.   //  information in it because it doesn't get updated fully
  82.   //  when the the user deletes an item from the group file.  That
  83.   //  is, the array doesn't get closed up to only include valid
  84.   //  offsets.  Instead, Windows puts 0 in the offset for the
  85.   //  deleted item.  So, what we're doing here is looking down the 
  86.   //  for non-zero entries in the array to get a true count (cItems)
  87.   //  of items in it.  In this way, we can use cItems as a limit in
  88.   //  the while loop below.
  89.   //**************************************************************
  90.  
  91.   _fmemcpy (&PMGroupHeader, lpGroupFileData, sizeof (PMGROUPHEADER));
  92.  
  93.   rgiItems = (WORD FAR *) &lpGroupFileData [sizeof (PMGROUPHEADER)];
  94.   i = cItems = 0;
  95.   while (i++ < PMGroupHeader.cItems)
  96.     {
  97.     if (*rgiItems)
  98.       cItems++;
  99.     rgiItems++;
  100.     }
  101.  
  102.   i = 0;
  103.   rgiItems = (WORD FAR *) &lpGroupFileData [sizeof (PMGROUPHEADER)];
  104.  
  105.   //  **************************************************************
  106.   //  Now that we have the count of valid items in the group file,
  107.   //  we cand go through and add the strings to the item list box.
  108.   //  **************************************************************
  109.   while (i < cItems)
  110.     {
  111.     if (*rgiItems)
  112.       {
  113.       i++;
  114.       // Get the item structure filled in
  115.       _fmemcpy (&PMItemData,
  116.                 &lpGroupFileData [*rgiItems],
  117.                 sizeof (PMITEMDATA));
  118.  
  119.       //  Do the item command
  120.       szTemp = szCommand;
  121.       do
  122.     *szTemp = lpGroupFileData [PMItemData.pCommand++];
  123.       while (*(szTemp++));
  124.       if(ShouldAppBeMinimized( (WORD) i))
  125.       WinExec(szCommand, SW_SHOWMINIMIZED);
  126.       else
  127.       WinExec(szCommand, SW_SHOWNORMAL);
  128.       }
  129.     rgiItems++;
  130.     }
  131.  
  132.     if(GlobalUnlock(ghMemGroupFileData))
  133.       GlobalFree(ghMemGroupFileData);
  134.  
  135.     return TRUE;
  136. }
  137.  
  138. //----------------------------------------------------------------------
  139. //     Function:  BOOL ReadGroupFile 
  140. //
  141. //   Parameters:  LPSTR lpszGroupFileName - Pointer to group file name
  142. //                *HGLOBAL ghMemGroupFileData - a pointer to the memory
  143. //                                              handle used to keep track
  144. //                                              of the global memory 
  145. //                                              allocated in this routine.
  146. // 
  147. //      Purpose:  Reads in the group file all at once. 
  148. //
  149. // Return Value:  Boolean indicating success or failure
  150. //--------------------------------------------------------------------
  151. BOOL ReadGroupFile (LPSTR lpszGroupFileName, PHANDLE ghMemGroupFileData)
  152. {
  153.   HFILE         fhGroupFile;
  154.   OFSTRUCT    OpenBuff;
  155.  
  156.   
  157.   // Get a handle to the group file
  158.  
  159.   if ((fhGroupFile = OpenFile (lpszGroupFileName, &OpenBuff, OF_READ)) == NULL)
  160.     return FALSE;
  161.  
  162.   // ******************************************************************
  163.   // Find out how much memory to allocate to hold the group file by
  164.   // seeking to the end of the file.  This gives us the number of 
  165.   // bytes that we have to allocate in the call to GlobalAlloc.
  166.   // ******************************************************************
  167.  
  168.   cbGroup = (WORD) _llseek (fhGroupFile, 0L, 2);
  169.   _llseek (fhGroupFile, 0L, 0);
  170.  
  171.   *ghMemGroupFileData = GlobalAlloc (GMEM_MOVEABLE, cbGroup);
  172.   lpGroupFileData = GlobalLock (*ghMemGroupFileData);
  173.   if (!lpGroupFileData)
  174.     {
  175.     _lclose (fhGroupFile);
  176.     return FALSE;
  177.     }
  178.  
  179.   if (!_lread (fhGroupFile, lpGroupFileData, cbGroup))
  180.     {
  181.     _lclose (fhGroupFile);
  182.  
  183.     if(GlobalUnlock (*ghMemGroupFileData))
  184.        GlobalFree (*ghMemGroupFileData);
  185.  
  186.     return FALSE;
  187.     }
  188.  
  189.   _lclose (fhGroupFile);
  190.   return TRUE;
  191. }
  192.  
  193. //----------------------------------------------------------------------
  194. int ShouldAppBeMinimized(WORD x)
  195.     {
  196.     struct tempTAGDATA {
  197.     WORD wID;
  198.     WORD wItem;
  199.     WORD cb;
  200.     } tempData;
  201.     char FAR *ptr; // *********
  202.  
  203.     tempData.wID = 0x8103; // ********
  204.     tempData.wItem = x - 1; // *********
  205.     tempData.cb = 0x06;
  206.  
  207.     for(ptr=lpGroupFileData; (ptr<=(lpGroupFileData + cbGroup-6)) &&
  208.         _fmemcmp(ptr,&tempData,sizeof(tempData)); ptr++); /* do nothing */
  209.  
  210.     return (ptr <= (lpGroupFileData + cbGroup-6));
  211.     }
  212.